[WIP]feat(miniapp): add built-in bitfun-loopx console MiniApp (replaces #2382) - #2836

Bundle of adapter-level fixes driven by a live A/B against the loopx
0.5.1 + codex reference run (same three fixture issues on both hosts):

- CLI adapter: inject --runtime-root <worktree>/.loopx/runtime on every
  loopx invocation; bootstrap passes --state-file into .loopx/goals and
  (after bootstrap) patches the registry common_runtime_root to the
  project-local runtime plus re-points legacy state_file away from
  .codex paths, so the worktree stays fully .loopx-namespaced and never
  touches the shared ~/.codex/loopx global registry.
- Turn instruction: append the pinned CLI reference and the verbatim
  pinned workflow-skill documents (loopx-project + loopx-self-repair
  SKILL.md) on the FIRST turn of each agent session only (codex-style
  session-start skill load; later turns carry a short pointer so prompt
  cache and per-turn cost stay low). Closing-ceremony note carries the
  exact required no_followup flag set and vision contract requirements.
- shell_analysis: accept powershell/pwsh/cmd dialects with hard input
  limits so the complete-shell guard stops failing closed on every
  Windows ExecCommand (whoami included).
- MiniApp UI: preserve the technical-receipt <details> open state
  across re-renders (was collapsing on every snapshot attach);
  suite-level pause_all/resume_all allowed by the web-ui bridge guard.
- build-loopx: bundle loopx skills via --add-data so the frozen sidecar
  ships the workflow-skill data (verified workflow-skills --install).
- AGENTS.md: record the codex-comparison methodology and the root-cause
  facts (runtime root localization, required closure flags, dialect
  guard) for future maintainers.

- Seed the pinned LoopX reference (CLI help reference + verbatim official
  workflow-skill documents) into .loopx/pinned-loopx-reference.md when the
  workspace connects; the turn instruction now only carries a short pointer
  (read once per session, reuse from context) instead of pasting ~130KB into
  every instruction - mirrors how a LoopX codex-style host loads its workflow
  skills, and keeps per-turn prompts cache-friendly.
- Slim LOOPX_CLOSING_CEREMONY_NOTE to host facts only: follow the reference
  document for schemas/flags; typed refusal -> apply the named parameter once,
  blocker after two ordered attempts; runtime stays project-local. The previous
  hand-written flag listing duplicated the docs and the 'minimal evidence'
  guidance caused repository_context=not_provided drift, so both were removed.

… terminal UX

Three live A/B runs against the loopx 0.5.1 + codex reference (same three
fixture issues) drove this batch; every fix cites its observed failure.

Execution parity (issue 1 went 16.7min -> 9.8min, faster than codex):
- Re-entry instructions now carry copy-ready settlement commands mirroring
  the pinned v0.5.1 canonical templates (effect_program.py writeback,
  autonomous_replan_obligation.py replan ACK with accountable
  delivery-outcome): the outer-controller envelope only ships a bare
  template, and agents re-derived flags from help text into 42 typed
  refusals ("turn-scoped refresh-state requires an accountable
  --delivery-outcome"; surface_only is not accountable).
- The replan ACK guidance embeds the exact goal_vision_replan_contract_v0
  packet shape with enforced budgets - the agent's own blocker todo asked
  the host to document this schema.
- Agent sessions now continue across turns of one goal (codex exec resume
  parity): settlement keeps the session for Queued/WaitingForUser turns,
  discards it on terminal/failure, and stale ids fall back to fresh
  sessions. Continued turns get an "already loaded" reference pointer
  (read policy has a single source: exactly one Read directive on the
  first turn, zero afterwards).
- agent-onboard pack is fetched after register-agent so it carries the
  registered agent id; monitor-recheck clock skew clamps at zero.

Owner-gated publishes (A9):
- Environment boundary now forbids git push / gh pr create / gh issue
  comment / gh pr merge unless the turn contract explicitly carries the
  approval, mirroring loopx requires_user_gate_before_external_write; a
  todo's text ("open a PR") is a plan description, not an authorization.
  Verified: 0 push/PR executions in the follow-up run (previously a PR
  was opened without approval).

Truthful projections (A7/A8):
- A user wait without a typed user_gate (e.g. the owner review/merge
  queue entry recorded after a PR) now projects as an owner-action
  summary and parks the task as waiting instead of failing the whole
  inspection and marking finished work recovery_required.
- The replan-lineage salvage accepts every typed envelope the pinned CLI
  still prints under that contract error (live settlement previously
  failed on an open blocker todo) and projects RunNow/Complete/Wait from
  the envelope shape.

Terminal UX:
- Completed goals render a plain-language outcome note (GitHub activity
  does not restart a finished goal) instead of the agent's control-plane
  next-step wording; verdict badges show the concrete reason (wont-fix
  rationale, missing info) instead of a repeated static note; the
  rejected-options block is gone; an empty issue body no longer renders
  as an endless "loading" placeholder.
- Agents must keep control-plane vocabulary out of human-facing summary
  fields, and a terminal-rejected quota spend is not a blocker (the goal
  is simply closed); completed tasks no longer render a blockers card.
- GitHub data must go through the gh CLI (direct WebFetch gets 403).

LoopX knowledge stays pinned: all embedded shapes (delivery outcomes,
vision contract, closeout flags) cite the pinned v0.5.1 validation code
by file and are regenerated when LOOPX_PINNED_VERSION moves. See the
bitfun-loopx AGENTS.md for the full run evidence and methodology.

LoopX v1.0.x moved the control-plane core (coordination state, turn
envelopes, vision checkpoints) to a managed TypeScript effect runtime the
Python sidecar starts on demand via `node --experimental-strip-types`.
Verified live against a clean v1.0.1 checkout: bootstrap fails closed with
"LoopX Effect runtime requires Node.js 22.6.0 or newer" when Node is
absent, so the upgrade ships a Node dependency surface instead of bundling
Node (installer size).

Runtime compatibility (each verified against the v1.0.1 source and the
rebuilt frozen sidecar, full chain bootstrap -> register-agent -> todo ->
turn plan -> guard -> refresh-state -> spend -> complete -> history):
- Every BitFun argv builder stays compatible; register-agent's new shape
  (no --project, global-registry write behind --execute) is exactly what
  BitFun already passes.
- All schemas BitFun parses are unchanged (turn_plan/envelope v0, workflow
  plan packet v0, settlement identity v0+v1, vision contract v0, progress
  observation v0, command reference v0).
- The turn-scoped refresh-state refusal was reworded but stays semantically
  equal (outcome_progress still qualifies); lineage error text, vision
  budgets, terminal-no-followup semantics, envelope budget all identical.
- Skills content: only loopx-self-repair and loopx-pr-review changed;
  pinned resources regenerated wholesale from v1.0.1 (CLI help reference
  recaptured across all eight commands).

Changes:
- Pin constants -> 1.0.1 / v1.0.1 / 7f2a020b (adapter, contracts, tests).
- build-loopx.mjs: stage the control-plane .ts/.json runtime sources as
  PyInstaller data (subset staging keeps .py modules out of the data area
  where loose sources could shadow frozen modules); compliance files now
  follow what the checkout carries (v1.0.1 dropped TRADEMARKS.md).
- Handshake now probes Node (>= 22.6, matching loopx's own floor) and
  returns it as LoopxNodeRuntimeFact on the manifest; the environment
  surface gains a core "Node.js" fact that blocks with an install hint
  when missing. Hermetic tests disable the probe via config.
- build_turn recognizes the guard's typed `turn_envelope_skipped`
  degradation (upstream #3687) and fails loudly with the skip reason
  instead of a generic missing-signature error.

Update the codex comparison baselines and reproduction manual in the
bitfun-loopx AGENTS.md with data from the 2026-09-08 v1.0.1 codex run:

- v1.0.1 baseline: issue #2 real fix 7m37s / 204K tokens / 58 execs,
  exact README +2 lines, stopped at owner gate, zero external writes.
  BitFun same issue 9.1 min - gap is ~1.5 min from per-turn host
  scheduling (inspect -> build -> settle), not agent execution.
- Corrected methodology: exec injection is not the official codex path
  (official goes TUI + skill discovery + heartbeat loop) but remains
  valid as comparison data since the guided packet structure drives
  the complete issue-fix loop.
- Documented sandbox pitfall: `--sandbox workspace-write` fails on
  Windows with `CreateProcessAsUserW failed: 5`; use
  `danger-full-access` with explicit operator safety boundaries.
- Documented v1.0.1 requirements for the lab: Node.js >= 22.6 on PATH
  (TS control plane), .cmd suffix needed for codex exec on Windows.
- Issue #1 no-op comparison incomplete (codex exec hung after
  register-agent for 17 min); noted for rerun.